package org.fastsyncer.parser.framework;

import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.fastsyncer.common.constant.ConnectorConstant;
import org.fastsyncer.common.constant.MappingConstant;
import org.fastsyncer.common.entity.MappingTask;
import org.fastsyncer.parser.database.DatabaseParser;
import org.json.JSONArray;

//单例模式类，通过.getInstance()来创建对象
public class ParserFactory implements Parser {

	// 实现单例模式的方法，通过方法来实现实例化
	// 声明一个私有的静态属性，使只被实例化一次
	private static final ParserFactory instance = new ParserFactory();

	// 声明一个私有的构造方法，使别人不能随便new对象
	// 它只被调用一次，实例存在之后就不再调用了
	private ParserFactory() {
	}

	// 声明一个公共的静态方法，外界通过调用这个方法来得到唯一的实例
	public static ParserFactory getInstance() {
		return instance;
	}

	@Override
	public Integer[] parse(MappingTask mappingTask, Integer startPos, Integer endPos) throws Exception {
		// 1.获取数据源数据
		List<Map<String, Object>> rows = this.parseSource(mappingTask, startPos, endPos);

		// 2.同步给目标源
		Integer[] result = this.syncTarget(mappingTask, rows);
		return result;
	}

	@Override
	public boolean parse(MappingTask mappingTask, String eventType, JSONArray before, JSONArray after)
			throws Exception {
		boolean sync = false;
		switch (mappingTask.getTargetMapping().getConnector()) {
		case ConnectorConstant.DB_CONNECTOR:
			// 处理增量同步业务

			// 2.解析事件类型
			// 新增操作
			if (StringUtils.equals(MappingConstant.SYNC_INCREMENT_TYPE_INSERT, eventType)) {
				sync = DatabaseParser.getInstance().insertToTargetDatabase(mappingTask, after);
				break;
			}

			// 修改操作
			if (StringUtils.equals(MappingConstant.SYNC_INCREMENT_TYPE_UPDATE, eventType)) {
				sync = DatabaseParser.getInstance().updateToTargetDatabase(mappingTask, after);
				break;
			}

			// 删除操作
			if (StringUtils.equals(MappingConstant.SYNC_INCREMENT_TYPE_DELETE, eventType)) {
				sync = DatabaseParser.getInstance().deleteToTargetDatabase(mappingTask, before);
				break;
			}
			break;
		default:
			break;
		}
		return sync;
	}

	// 解析数据源
	private List<Map<String, Object>> parseSource(MappingTask mappingTask, Integer startPos, Integer endPos)
			throws Exception {
		List<Map<String, Object>> rows = null;
		switch (mappingTask.getSourceMapping().getConnector()) {
		case ConnectorConstant.DB_CONNECTOR:
			// 解析数据源Database类型
			rows = DatabaseParser.getInstance().parseSourceDatabase(mappingTask, startPos, endPos);
			break;
		default:
			break;
		}
		return rows;
	}

	// 同步目标源
	private Integer[] syncTarget(MappingTask mappingTask, List<Map<String, Object>> rows) throws Exception {
		Integer[] sync = null;
		switch (mappingTask.getTargetMapping().getConnector()) {
		case ConnectorConstant.DB_CONNECTOR:
			// 同步数据源Database类型
			sync = DatabaseParser.getInstance().syncTargetDatabase(mappingTask, rows);
			break;
		default:
			break;
		}
		return sync;
	}

}
